/**
 * API缓存拦截器
 * 为HTTP请求提供自动缓存功能
 */

import { cacheManager, CACHE_TYPES } from './cacheManager'

// 缓存配置
const CACHE_CONFIG = {
  // 默认缓存时间（毫秒）
  DEFAULT_TTL: 5 * 60 * 1000, // 5分钟
  
  // 不同类型请求的缓存策略
  STRATEGIES: {
    // GET请求默认缓存
    GET: {
      enabled: true,
      ttl: 5 * 60 * 1000,
      type: CACHE_TYPES.MEMORY
    },
    // POST请求通常不缓存
    POST: {
      enabled: false
    },
    // PUT请求不缓存
    PUT: {
      enabled: false
    },
    // DELETE请求不缓存
    DELETE: {
      enabled: false
    }
  },
  
  // 特定API的缓存配置
  API_SPECIFIC: {
    '/api/user/profile': {
      enabled: true,
      ttl: 10 * 60 * 1000, // 10分钟
      type: CACHE_TYPES.LOCAL_STORAGE,
      priority: 'high'
    },
    '/api/departments': {
      enabled: true,
      ttl: 30 * 60 * 1000, // 30分钟
      type: CACHE_TYPES.LOCAL_STORAGE,
      priority: 'medium'
    },
    '/api/doctors': {
      enabled: true,
      ttl: 15 * 60 * 1000, // 15分钟
      type: CACHE_TYPES.MEMORY,
      priority: 'medium'
    },
    '/api/health/records': {
      enabled: true,
      ttl: 2 * 60 * 1000, // 2分钟
      type: CACHE_TYPES.SESSION_STORAGE,
      priority: 'high'
    },
    '/api/health-analytics': {
      enabled: true,
      ttl: 15 * 60 * 1000, // 15分钟
      type: CACHE_TYPES.MEMORY,
      priority: 'high'
    },
    '/api/vital-signs': {
      enabled: true,
      ttl: 10 * 60 * 1000, // 10分钟
      type: CACHE_TYPES.MEMORY,
      priority: 'high'
    },
    '/api/trend-analysis': {
      enabled: true,
      ttl: 30 * 60 * 1000, // 30分钟
      type: CACHE_TYPES.LOCAL_STORAGE,
      priority: 'medium'
    },
    '/api/analytics': {
      enabled: true,
      ttl: 3 * 60 * 1000, // 3分钟
      type: CACHE_TYPES.MEMORY,
      priority: 'low'
    },
    '/api/system-stats': {
      enabled: true,
      ttl: 60 * 60 * 1000, // 1小时
      type: CACHE_TYPES.LOCAL_STORAGE,
      priority: 'low'
    }
  }
}

/**
 * 生成缓存键
 * @param {string} method - HTTP方法
 * @param {string} url - 请求URL
 * @param {Object} params - 请求参数
 * @param {Object} data - 请求数据
 * @returns {string} 缓存键
 */
function generateCacheKey(method, url, params = {}, data = {}) {
  const normalizedUrl = url.split('?')[0] // 移除查询参数
  const sortedParams = JSON.stringify(params, Object.keys(params).sort())
  const sortedData = JSON.stringify(data, Object.keys(data).sort())
  
  return `api_${method}_${normalizedUrl}_${sortedParams}_${sortedData}`
}

/**
 * 获取API缓存配置
 * @param {string} method - HTTP方法
 * @param {string} url - 请求URL
 * @returns {Object} 缓存配置
 */
function getCacheConfig(method, url) {
  const normalizedUrl = url.split('?')[0]
  
  // 检查特定API配置
  if (CACHE_CONFIG.API_SPECIFIC[normalizedUrl]) {
    return CACHE_CONFIG.API_SPECIFIC[normalizedUrl]
  }
  
  // 使用默认策略
  return CACHE_CONFIG.STRATEGIES[method.toUpperCase()] || { enabled: false }
}

/**
 * 检查响应是否可缓存
 * @param {Object} response - HTTP响应
 * @returns {boolean} 是否可缓存
 */
function isResponseCacheable(response) {
  // 只缓存成功的响应
  if (response.status < 200 || response.status >= 300) {
    return false
  }
  
  // 检查响应头
  const cacheControl = response.headers?.['cache-control']
  if (cacheControl && cacheControl.includes('no-cache')) {
    return false
  }
  
  return true
}

/**
 * 请求拦截器 - 检查缓存
 * @param {Object} config - 请求配置
 * @returns {Object|Promise} 缓存的响应或原始配置
 */
export function requestInterceptor(config) {
  const { method = 'GET', url, params, data } = config
  const cacheConfig = getCacheConfig(method, url)
  
  // 如果不启用缓存，直接返回配置
  if (!cacheConfig.enabled) {
    return config
  }
  
  // 生成缓存键
  const cacheKey = generateCacheKey(method, url, params, data)
  
  // 尝试从缓存获取
  const cachedResponse = cacheManager.get(cacheKey, cacheConfig.type)
  
  if (cachedResponse) {
    console.log(`Cache hit for ${method} ${url}`)
    
    // 返回缓存的响应，包装成Promise
    return Promise.resolve({
      data: cachedResponse.data,
      status: cachedResponse.status,
      statusText: cachedResponse.statusText,
      headers: cachedResponse.headers,
      config,
      fromCache: true
    })
  }
  
  // 在配置中标记需要缓存
  config._cacheConfig = cacheConfig
  config._cacheKey = cacheKey
  
  return config
}

/**
 * 响应拦截器 - 存储缓存
 * @param {Object} response - HTTP响应
 * @returns {Object} 响应对象
 */
export function responseInterceptor(response) {
  const { config } = response
  const cacheConfig = config._cacheConfig
  const cacheKey = config._cacheKey
  
  // 如果有缓存配置且响应可缓存
  if (cacheConfig && cacheKey && isResponseCacheable(response)) {
    const cacheData = {
      data: response.data,
      status: response.status,
      statusText: response.statusText,
      headers: response.headers,
      timestamp: Date.now()
    }
    
    // 存储到缓存
    cacheManager.set(cacheKey, cacheData, {
      ttl: cacheConfig.ttl || CACHE_CONFIG.DEFAULT_TTL,
      type: cacheConfig.type || CACHE_TYPES.MEMORY
    })
    
    console.log(`Cached response for ${config.method} ${config.url}`)
  }
  
  // 清理临时配置
  delete config._cacheConfig
  delete config._cacheKey
  
  return response
}

/**
 * 错误拦截器 - 处理缓存相关错误
 * @param {Object} error - 错误对象
 * @returns {Promise} 拒绝的Promise
 */
export function errorInterceptor(error) {
  const { config } = error
  
  // 清理临时配置
  if (config) {
    delete config._cacheConfig
    delete config._cacheKey
  }
  
  return Promise.reject(error)
}

/**
 * 清除特定API的缓存
 * @param {string} method - HTTP方法
 * @param {string} url - 请求URL
 * @param {Object} params - 请求参数
 * @param {Object} data - 请求数据
 */
export function clearApiCache(method, url, params = {}, data = {}) {
  const cacheKey = generateCacheKey(method, url, params, data)
  const cacheConfig = getCacheConfig(method, url)
  
  if (cacheConfig.enabled) {
    cacheManager.delete(cacheKey, cacheConfig.type)
    console.log(`Cleared cache for ${method} ${url}`)
  }
}

/**
 * 清除URL模式匹配的缓存
 * @param {string} urlPattern - URL模式（支持通配符）
 */
export function clearCacheByPattern(urlPattern) {
  // 这里可以实现更复杂的模式匹配逻辑
  // 目前简单实现：清除包含特定字符串的缓存
  console.log(`Clearing cache for pattern: ${urlPattern}`)
  
  // 由于缓存键的复杂性，这里建议清除所有缓存
  // 在实际应用中，可以维护一个URL到缓存键的映射
  cacheManager.clearAll()
}

/**
 * 预热缓存 - 预先加载常用数据
 * @param {Array} requests - 请求配置数组
 */
export async function warmupCache(requests) {
  console.log('Starting cache warmup...')
  
  const promises = requests.map(async (request) => {
    try {
      // 这里需要实际的HTTP客户端实例
      // 示例代码，实际使用时需要传入axios实例
      console.log(`Warming up cache for ${request.method} ${request.url}`)
      // await httpClient(request)
    } catch (error) {
      console.warn(`Cache warmup failed for ${request.url}:`, error.message)
    }
  })
  
  await Promise.allSettled(promises)
  console.log('Cache warmup completed')
}

/**
 * 智能缓存清理策略
 */
class SmartCacheManager {
  constructor() {
    this.priorityWeights = {
      'high': 3,
      'medium': 2,
      'low': 1
    }
    
    // 定期清理过期缓存
    this.startCleanupTimer()
  }

  /**
   * 启动清理定时器
   */
  startCleanupTimer() {
    // 每5分钟清理一次过期缓存
    setInterval(() => {
      this.cleanupExpiredCache()
    }, 5 * 60 * 1000)
    
    // 每30分钟进行智能清理
    setInterval(() => {
      this.smartCleanup()
    }, 30 * 60 * 1000)
  }

  /**
   * 清理过期缓存
   */
  cleanupExpiredCache() {
    const stats = cacheManager.getStats()
    let cleanedCount = 0
    
    // 清理内存缓存中的过期项
    Object.keys(CACHE_CONFIG.API_SPECIFIC).forEach(apiPath => {
      const config = CACHE_CONFIG.API_SPECIFIC[apiPath]
      if (config.type === CACHE_TYPES.MEMORY) {
        // 这里可以添加具体的过期检查逻辑
        cleanedCount++
      }
    })
    
    console.log(`清理了 ${cleanedCount} 个过期缓存项`)
  }

  /**
   * 智能清理 - 基于优先级和使用频率
   */
  smartCleanup() {
    const stats = cacheManager.getStats()
    
    // 如果内存使用超过阈值，清理低优先级缓存
    if (stats.memory && stats.memory.size > stats.memory.maxSize * 0.8) {
      this.cleanupByPriority(['low'])
    }
    
    // 如果内存使用超过90%，清理中等优先级缓存
    if (stats.memory && stats.memory.size > stats.memory.maxSize * 0.9) {
      this.cleanupByPriority(['low', 'medium'])
    }
  }

  /**
   * 按优先级清理缓存
   */
  cleanupByPriority(priorities) {
    Object.entries(CACHE_CONFIG.API_SPECIFIC).forEach(([apiPath, config]) => {
      if (priorities.includes(config.priority)) {
        const cacheKey = generateCacheKey('GET', apiPath, {})
        cacheManager.delete(cacheKey, config.type)
      }
    })
  }

  /**
   * 预热关键缓存
   */
  async warmupCache(userId) {
    const criticalApis = [
      '/api/user/profile',
      '/api/health-analytics',
      '/api/vital-signs'
    ]
    
    for (const api of criticalApis) {
      try {
        // 这里可以添加预热请求逻辑
        console.log(`预热缓存: ${api}`)
      } catch (error) {
        console.warn(`预热缓存失败: ${api}`, error)
      }
    }
  }
}

// 创建智能缓存管理器实例
const smartCacheManager = new SmartCacheManager()

/**
 * 缓存统计信息
 */
export function getCacheStats() {
  return {
    ...cacheManager.getStats(),
    config: CACHE_CONFIG
  }
}

/**
 * 缓存管理工具
 */
export const cacheUtils = {
  clear: clearApiCache,
  clearByPattern: clearCacheByPattern,
  warmup: warmupCache,
  stats: getCacheStats,
  manager: cacheManager,
  
  /**
   * 清空所有缓存
   */
  clearAll() {
    cacheManager.clearAll()
  },

  /**
   * 清空指定类型的缓存
   */
  clearByType(type) {
    cacheManager.clear(type)
  },

  /**
   * 按优先级清理缓存
   */
  clearByPriority(priorities) {
    smartCacheManager.cleanupByPriority(priorities)
  },

  /**
   * 预热缓存
   */
  warmupSmart(userId) {
    return smartCacheManager.warmupCache(userId)
  },

  /**
   * 手动触发智能清理
   */
  smartCleanup() {
    smartCacheManager.smartCleanup()
  },

  /**
   * 获取缓存健康状态
   */
  getHealthStatus() {
    const stats = getCacheStats()
    const memoryUsage = stats.memory ? stats.memory.size / stats.memory.maxSize : 0
    
    return {
      status: memoryUsage > 0.9 ? 'critical' : memoryUsage > 0.7 ? 'warning' : 'healthy',
      memoryUsage: Math.round(memoryUsage * 100),
      recommendations: this.getRecommendations(memoryUsage)
    }
  },

  /**
   * 获取优化建议
   */
  getRecommendations(memoryUsage) {
    const recommendations = []
    
    if (memoryUsage > 0.8) {
      recommendations.push('建议清理低优先级缓存')
    }
    
    if (memoryUsage > 0.9) {
      recommendations.push('建议立即清理缓存以释放内存')
    }
    
    if (memoryUsage < 0.3) {
      recommendations.push('可以增加缓存大小以提高性能')
    }
    
    return recommendations
  }
}

export default {
  requestInterceptor,
  responseInterceptor,
  errorInterceptor,
  cacheUtils
}